#include "productmodel.h"
#include <QDebug>
#include <QSqlError>

// 初始化列名列表（与数据库表字段对应，顺序需严格一致）
const QStringList COLUMN_NAMES = {
    "product_id",       // 0: 商品ID（不可编辑）
    "product_name",     // 1: 商品名称
    "specification",    // 2: 规格
    "color",            // 3: 颜色
    "supplier",         // 4: 供应商
    "purchase_price",   // 5: 进货价（可编辑）
    "selling_price",    // 6: 售价（可编辑）
    "category_id",      // 7: 分类ID（可编辑）
    "allow_member_discount" // 8: 是否允许会员折扣（可编辑）
};

// 构造函数：接收DAO实例，初始化列名
ProductModel::ProductModel(ProductDAO *dao, QObject *parent)
    : QAbstractTableModel(parent), m_dao(dao), m_columns(COLUMN_NAMES)
{
    // 初始化时可选择预加载数据（根据业务需求）
    // loadAllProducts();
}

// 返回行数（商品数量）
int ProductModel::rowCount(const QModelIndex &parent) const
{
    Q_UNUSED(parent);
    return m_products.size();
}

// 返回列数（固定为商品属性数量）
int ProductModel::columnCount(const QModelIndex &parent) const
{
    Q_UNUSED(parent);
    return m_columns.size();
}

// 核心方法：提供单元格数据（根据角色返回不同格式）
QVariant ProductModel::data(const QModelIndex &index, int role) const
{
    // 索引有效性检查
    if (!index.isValid()
        || index.row() < 0
        || index.row() >= m_products.size()
        || index.column() >= m_columns.size()) {
        return QVariant();
    }

    const QMap<QString, QVariant> &product = m_products[index.row()];
    QString columnName = m_columns[index.column()];

    // 显示角色：格式化显示（如布尔值转文字）
    if (role == Qt::DisplayRole) {
        if (columnName == "allow_member_discount") {
            // 数据库存储为1/0，显示为"是/否"
            return product[columnName].toInt() == 1 ? tr("是") : tr("否");
        } else if (columnName == "purchase_price" || columnName == "selling_price") {
            // 价格显示保留两位小数
            return QString("¥ %1").arg(product[columnName].toDouble(), 0, 'f', 2);
        }
        return product[columnName];
    }

    // 编辑角色：返回原始数据（供编辑器使用）
    if (role == Qt::EditRole) {
        return product[columnName];
    }

    // 对齐角色：价格和布尔值列居中显示
    if (role == Qt::TextAlignmentRole) {
        if (columnName == "purchase_price"
            || columnName == "selling_price"
            || columnName == "allow_member_discount"
            || columnName == "category_id") {
            return Qt::AlignCenter;
        }
    }

    return QVariant();
}

// 表头数据（水平表头显示中文名称，垂直表头显示行号）
QVariant ProductModel::headerData(int section, Qt::Orientation orientation, int role) const
{
    if (role != Qt::DisplayRole) {
        return QVariant();
    }

    // 水平表头（列名）
    if (orientation == Qt::Horizontal) {
        switch (section) {
        case 0: return tr("商品ID");
        case 1: return tr("商品名称");
        case 2: return tr("规格");
        case 3: return tr("颜色");
        case 4: return tr("供应商");
        case 5: return tr("进货价");
        case 6: return tr("售价");
        case 7: return tr("分类ID");
        case 8: return tr("会员折扣");
        default: return QVariant();
        }
    }

    // 垂直表头（行号，从1开始）
    return section + 1;
}

// 声明单元格编辑权限（仅特定列可编辑）
Qt::ItemFlags ProductModel::flags(const QModelIndex &index) const
{
    if (!index.isValid())
        return Qt::NoItemFlags;

    // 基础标志（可选中、可启用）
    Qt::ItemFlags flags = QAbstractTableModel::flags(index);

    // 为指定列添加编辑权限
    int column = index.column();
    if (column == 5  // 进货价
        || column == 6  // 售价
        || column == 7  // 分类ID
        || column == 8) {  // 会员折扣
        flags |= Qt::ItemIsEditable;
    }

    return flags;
}

// 处理单元格数据修改（核心：同步到数据库）
bool ProductModel::setData(const QModelIndex &index, const QVariant &value, int role)
{
    // 有效性检查
    if (!index.isValid() || role != Qt::EditRole)
        return false;

    int row = index.row();
    int column = index.column();
    if (row < 0 || row >= m_products.size() || column >= m_columns.size())
        return false;

    QString columnName = m_columns[column];
    QMap<QString, QVariant> &product = m_products[row];
    int productId = product["product_id"    ].toInt();

    // -------------------------- 数据验证 --------------------------
    bool isValid = true;
    QString errorMsg;

    if (columnName == "purchase_price" || columnName == "selling_price") {
        // 价格验证：必须>0且保留两位小数
        double price = value.toDouble();
        if (price <= 0) {
            isValid = false;
            errorMsg = tr("价格必须大于0");
        } else if (price > 99999.99) {
            isValid = false;
            errorMsg = tr("价格不能超过99999.99");
        }
    } else if (columnName == "category_id") {
        // 分类ID验证：必须为正整数
        int categoryId = value.toInt();
        if (categoryId <= 0) {
            isValid = false;
            errorMsg = tr("分类ID必须为正整数");
        }
    }

    if (!isValid) {
        emit dataError(errorMsg);  // 发射错误信号（需在头文件声明）
        return false;
    }
    // --------------------------------------------------------------

    // 临时保存原始值（用于数据库更新失败时回滚）
    QVariant originalValue = product[columnName];

    // 更新模型缓存（内存数据）
    if (columnName == "allow_member_discount") {
        // 布尔值特殊处理（数据库存储为1/0）
        product[columnName] = value.toBool() ? 1 : 0;
    } else {
        product[columnName] = value;
    }

    // 调用DAO同步到数据库
    bool dbSuccess = m_dao->updateProductField(productId, columnName, product[columnName]);
    if (!dbSuccess) {
        // 数据库更新失败：回滚模型数据
        product[columnName] = originalValue;
        emit dataError(tr("更新失败：数据库操作异常"));
        return false;
    }

    // 通知视图数据已更新
    emit dataChanged(index, index, {role});
    return true;
}

// 从数据库加载所有商品（刷新数据）
bool ProductModel::loadAllProducts()
{
    if (!m_dao) {
        emit dataError(tr("数据访问对象未初始化"));
        return false;
    }

    beginResetModel();  // 通知视图开始重置数据（避免频繁刷新）
    m_products = m_dao->getAllProducts();  // 调用DAO获取数据
    endResetModel();    // 通知视图数据已就绪

    bool loadSuccess = !m_products.isEmpty();
    if (!loadSuccess) {
        emit dataError(tr("未加载到商品数据"));
    }
    return loadSuccess;
}

// 根据ID查询商品详情
QMap<QString, QVariant> ProductModel::getProductById(int productId)
{
    if (!m_dao) {
        emit dataError(tr("数据访问对象未初始化"));
        return QMap<QString, QVariant>();
    }

    return m_dao->getProductById(productId);
}

// 添加商品（同步到数据库和模型）
bool ProductModel::addProduct(const QMap<QString, QVariant> &productData)
{
    if (!m_dao) {
        emit dataError(tr("数据访问对象未初始化"));
        return false;
    }

    // 调用DAO添加到数据库
    bool dbSuccess = m_dao->addProduct(
        productData["product_name"].toString(),
        productData["specification"].toString(),
        productData["color"].toString(),
        productData["supplier"].toString(),
        productData["purchase_price"].toDouble(),
        productData["selling_price"].toDouble(),
        productData["category_id"].toInt(),
        productData["allow_member_discount"].toBool()
    );

    if (dbSuccess) {
        // 添加成功后重新加载数据（刷新视图）
        loadAllProducts();
    } else {
        emit dataError(tr("添加失败：数据库操作异常"));
    }
    return dbSuccess;
}

// 批量更新商品信息
bool ProductModel::updateProduct(int productId, const QMap<QString, QVariant> &productData)
{
    if (!m_dao) {
        emit dataError(tr("数据访问对象未初始化"));
        return false;
    }

    // 调用DAO批量更新数据库
    bool dbSuccess = m_dao->updateProduct(
        productId,
        productData["product_name"].toString(),
        productData["specification"].toString(),
        productData["color"].toString(),
        productData["supplier"].toString(),
        productData["purchase_price"].toDouble(),
        productData["selling_price"].toDouble(),
        productData["category_id"].toInt(),
        productData["allow_member_discount"].toBool()
    );

    if (dbSuccess) {
        // 查找更新的行并通知视图刷新
        for (int i = 0; i < m_products.size(); ++i) {
            if (m_products[i]["product_id"].toInt() == productId) {
                QModelIndex topLeft = index(i, 0);
                QModelIndex bottomRight = index(i, columnCount() - 1);
                emit dataChanged(topLeft, bottomRight);  // 通知整行数据变化
                break;
            }
        }
    } else {
        emit dataError(tr("更新失败：数据库操作异常"));
    }
    return dbSuccess;
}

// 删除商品（同步到数据库和模型）
bool ProductModel::deleteProduct(int row)
{
    if (row < 0 || row >= m_products.size() || !m_dao) {
        return false;
    }

    // 获取商品ID
    int productId = m_products[row]["product_id"].toInt();

    // 调用DAO删除数据库记录
    bool dbSuccess = m_dao->deleteProduct(productId);
    if (dbSuccess) {
        beginRemoveRows(QModelIndex(), row, row);  // 通知视图开始删除
        m_products.removeAt(row);  // 从模型缓存中移除
        endRemoveRows();  // 通知视图删除完成
    } else {
        emit dataError(tr("删除失败：数据库操作异常"));
    }
    return dbSuccess;
}

// 按名称搜索商品
bool ProductModel::searchProducts(const QString &name)
{
    if (!m_dao) {
        emit dataError(tr("数据访问对象未初始化"));
        return false;
    }

    beginResetModel();  // 通知视图重置数据
    m_products = m_dao->searchProductsByName(name);  // 调用DAO搜索
    endResetModel();

    bool hasResult = !m_products.isEmpty();
    if (!hasResult) {
        emit dataError(tr("未找到匹配的商品"));
    }
    return hasResult;
}

// productmodel.cpp
bool ProductModel::filterByCategory(int categoryId)
{
    if (!m_dao) {
        emit dataError(tr("数据访问对象未初始化"));
        return false;
    }

    beginResetModel();

    if (categoryId == -1) {
        // -1 表示"全部分类"
        m_products = m_dao->getAllProducts();
    } else {
        m_products = m_dao->getProductsByCategory(categoryId);
    }

    endResetModel();

    bool hasResult = !m_products.isEmpty();
    if (!hasResult) {
        emit dataError(tr("未找到该分类的商品"));
    }
    return hasResult;
}

QVector<QMap<QString, QVariant>> ProductModel::getAllCategories()
{
    if (!m_dao) {
        emit dataError(tr("数据访问对象未初始化"));
        return QVector<QMap<QString, QVariant>>();
    }
    return m_dao->getAllCategories();
}


QVector<QMap<QString, QVariant>> ProductModel::getAllProducts() const
{
    return m_products;
}


QMap<int, int> ProductModel::getCategoryStatistics()
{
    if (!m_dao) {
        emit dataError(tr("数据访问对象未初始化"));
        return QMap<int, int>();
    }

    return m_dao->getCategoryStatistics();
}
